Implementation of complex systems involves the specification and development of components and the integration of these components to derive the complete or composite system.
To place in perspective the context of the present invention, the case of the composition of hardware elements is first elucidated. Hardware, either a printed circuit board or an integrated circuit, is developed using Computer Aided Design (CAD) tools. A design is built by placing reusable components on a schematic diagram. These components typically are stored in a library of standard components. The library representation of each component includes a pictorial representation which depicts the component's external connections, and an executable behavioral model of the component. Once a plurality of components have been placed on a schematic diagram the designer interconnects the components by introducing wires into the schematic. At this point, the designer can simulate the circuit being designed by using the behavioral specifications from the component library and the interconnection pattern of the overall schematic. In addition, the entire composite schematic may be associated with a pictorial image, and a list of its ports which are available to other, outside components may be devised; both the image and list are stored into the component library as an entirely new component. This new component may now be called upon to create another, generally more complex schematic. This ability to "compose" multiple objects into a single object makes it both possible and practical to reuse hardware designs.
It is informative to contemplate the properties of a wire which facilitate the interconnection of hardware components in a seamless, transparent fashion. A wire is both lossless and symmetric. Lossless means that signals are never discarded by the wire. Symmetric means that any signal applied at one end of the wire will appear at the other end of the wire, and that the wire is bi-directional, that is, the wire behaves the same no matter which end is used to transmit the signal (in more complex cases, the signal may be modeled as appearing at the other end of the wire after a time delay). These simple but elegant properties permit straightforward mathematical modeling of communications over wires. These very properties of a wire might be said to be the "missing link" in the design and implementation of software systems.
Recently, in the domain of software design, object-oriented programming has become widely accepted as a useful procedure to reuse software. In object-oriented software systems, objects do not communicate by wires, but rather by messages which the objects exchange with one another. Each object has a queue from which it retrieves and processes messages. The state of an object can be traced by its initial state and by the history of its message queue. Changing the order of arrival of messages obviously affects the state of the object, as well as the system into which the object is embedded. In a single processor system, changing the order of the arrival of messages from message originators outside the object is not a concern since, at any instant of time, there can only one active object (thread of computation). However, in a distributed system wherein there are multiple objects active concurrently, inconsistent behavior of the system may occur when the order of arrival of messages to an object is basically unknown and unpredictable to each object unless special precautions are taken to protect against this occurrence. Composition of a plurality of objects to create an composite object which is subject to the principles of object-oriented programming is not possible with the teachings of the prior art. The reason why such a composition in the conventional sense cannot be effected may be succinctly explained as follows. Multiple objects ("sub-objects"), which are to be composed into a single object ("super-object"), each have a their own queue. The composition of these sub-objects into the super-object must be such that the super-object has a single queue of its own. To accomplish this composition, it is necessary to impose some rules in order to properly sequence the message queues associated with the sub-objects. Unfortunately, these rules do not conform to the object model, and therefore places the super-object outside the domain of the object model itself. The end result is that object re-use, a prime motivator for object-oriented programming, is much more limited in software design as contrasted to hardware design.
As alluded to above, it is common today to design and implement systems from subsystems referred to here as Objects by providing for communications between Objects. The most common method is to simply allow one Object to send and receive messages to another. The simplicity of this concept hides its potential to create chaos in large systems. Various unspecified conditions such as how many messages can one Object send another, must an object always be ready to receive messages? Can one Object send another an unexpected message or a message that produces an error in the receiving Object? in recent past, these problems have led to a large number of protocols, rules for sending and receiving messages, in an attempt to solve them. However, this approach becomes very specific to the particular system that is constructed. Therefore, systems in general cannot be composed from canonical Objects. In synchronous hardware systems, on the other hand, the mathematical concept of a wire which distributes data and is controlled by a physical clock defining stable cycles, allows a canonical method to connect hardware elements. The symmetry and uniformity with which this abstraction is applied throughout the hardware development process is perhaps the single most important pad of the process.
The process of producing systems involves well known stages of modeling, specification, design, development, implementation, testing, and maintenance. It has become acutely evident in the recent past that this process critically depends on the model of concurrent computation that is used to model software and hardware objects. The process itself is acknowledged to be iterative with multiple concurrent iterations of stages by teams of developers. The success of object oriented technology has brought the problem of finding such a model to the forefront. In any serious system, a multiplicity of objects exists and these objects interact to implement the requirements of the system as a whole. Therefore, the coordinated behavior of collections of objects describes as well as implements the system. The importance of these problems has resulted in various international standard bodies who are actively seeking a model of objects that will serve as a basis for influencing the whole range of stages involved in software development. A method based on an abstraction which can be as uniformly applied as the wire in hardwire would alleviate some of the serious problems of developing systems. This abstraction has been, as yet, unavailable for general systems composed of hardware as well as software, or for software only systems. The closest form of prior art is VHDL (VHSIC Hardware Description Language), (a representative reference for VHDL is the textbook entitled VHDL, as authored by Douglas L. Perry and as published by McGraw-Hill, 1991), which is the latest in a family of languages which has proven very useful for hardware development. We briefly point out the function, use and importance of VHDL. We then discuss the innovative aspects of Interface Cycles.